package com.cskaoyan.mall.product.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.cskaoyan.mall.common.constant.RedisConst;
import com.cskaoyan.mall.product.converter.dto.PlatformAttrConverter;
import com.cskaoyan.mall.product.converter.dto.SkuInfoConverter;
import com.cskaoyan.mall.product.converter.dto.SkuInfoPageConverter;
import com.cskaoyan.mall.product.converter.dto.SpuInfoConverter;
import com.cskaoyan.mall.product.converter.param.SkuInfoParamConverter;
import com.cskaoyan.mall.product.dto.*;
import com.cskaoyan.mall.product.mapper.*;
import com.cskaoyan.mall.product.model.*;
import com.cskaoyan.mall.product.query.SkuInfoParam;
import com.cskaoyan.mall.product.service.SalesAttrService;
import com.cskaoyan.mall.product.service.SkuService;
import org.redisson.api.RBloomFilter;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * @author Macro_Ray
 * @since 2024/6/11 下午9:33
 */
@Service
public class SkuServiceImpl implements SalesAttrService, SkuService {

    @Autowired
    SpuInfoConverter spuInfoConverter;
    @Autowired
    SkuInfoConverter skuInfoConverter;
    @Autowired
    SkuInfoParamConverter skuInfoParamConverter;
    @Autowired
    SkuInfoPageConverter skuInfoPageConverter;
    @Autowired
    PlatformAttrConverter platformAttrConverter;
    @Autowired
    SpuSaleAttrInfoMapper spuSaleAttrInfoMapper;
    @Autowired
    SpuImageMapper spuImageMapper;
    @Autowired
    SkuInfoMapper skuInfoMapper;
    @Autowired
    SkuImageMapper skuImageMapper;
    @Autowired
    SkuSaleAttrValueMapper skuSaleAttrValueMapper;
    @Autowired
    SkuPlatformAttrValueMapper skuPlatformAttrValueMapper;
    @Autowired
    PlatformAttrInfoMapper platformAttrInfoMapper;
    @Autowired
    RedissonClient redissonClient;

    /**
     * 根据spuId查询商品销售属性列表
     */
    @Override
    public List<SpuSaleAttrInfoDTO> getSpuSaleAttrList(Long spuId) {
        List<SpuSaleAttrInfo> spuSaleAttrInfos = spuSaleAttrInfoMapper.selectSpuSaleAttrList(spuId);
        return spuInfoConverter.spuSaleAttrInfoPOs2DTOs(spuSaleAttrInfos);
    }

    /**
     * 根据spuId查询商品图片列表
     */
    @Override
    public List<SpuImageDTO> getSpuImageList(Long spuId) {
        LambdaQueryWrapper<SpuImage> spuImageLambdaQueryWrapper = new LambdaQueryWrapper<>();
        spuImageLambdaQueryWrapper.eq(SpuImage::getSpuId, spuId);
        List<SpuImage> spuImageList = spuImageMapper.selectList(spuImageLambdaQueryWrapper);
        return spuInfoConverter.spuImagePOs2DTOs(spuImageList);
    }

    /**
     * 保存SKU信息，包括sku_info、sku_images、sku_sale_attr_value、sku_platform_attr_value四张表
     */
    @Override
    public void saveSkuInfo(SkuInfoParam skuInfoParam) {
        // sku_info表
        SkuInfo skuInfo = skuInfoParamConverter.SkuInfoParam2Info(skuInfoParam);
        skuInfoMapper.insert(skuInfo);
        // sku_images表
        List<SkuImage> skuImageList = skuInfo.getSkuImageList();
        if (!CollectionUtils.isEmpty(skuImageList)) {
            for (SkuImage skuImage : skuImageList) {
                skuImage.setSkuId(skuInfo.getId());
                skuImageMapper.insert(skuImage);
            }
        }
        // sku_sale_attr_value表
        List<SkuSaleAttrValue> skuSaleAttrValueList = skuInfo.getSkuSaleAttrValueList();
        if (!CollectionUtils.isEmpty(skuSaleAttrValueList)) {
            for (SkuSaleAttrValue skuSaleAttrValue : skuSaleAttrValueList) {
                skuSaleAttrValue.setSkuId(skuInfo.getId());
                skuSaleAttrValue.setSpuId(skuInfo.getSpuId());
                skuSaleAttrValueMapper.insert(skuSaleAttrValue);
            }
        }
        // sku_platform_attr_value表
        List<SkuPlatformAttrValue> skuPlatformAttrValueList = skuInfo.getSkuPlatformAttrValueList();
        if (!CollectionUtils.isEmpty(skuPlatformAttrValueList)) {
            for (SkuPlatformAttrValue skuPlatformAttrValue : skuPlatformAttrValueList) {
                skuPlatformAttrValue.setSkuId(skuInfo.getId());
                skuPlatformAttrValueMapper.insert(skuPlatformAttrValue);
            }
        }
    }

    /**
     * 查询所有SKU分页信息
     */
    @Override
    public SkuInfoPageDTO getSkuPageList(Page<SkuInfo> pageParam) {
        LambdaQueryWrapper<SkuInfo> skuInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        skuInfoLambdaQueryWrapper.orderByDesc(SkuInfo::getId);
        Page<SkuInfo> skuInfoPage = skuInfoMapper.selectPage(pageParam, skuInfoLambdaQueryWrapper);
        return skuInfoPageConverter.skuInfoPagePO2PageDTO(skuInfoPage);
    }

    /**
     * SKU商品上架
     */
    @Override
    public void onSale(Long skuId) {
        // LambdaUpdateWrapper<SkuInfo> skuInfoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        // skuInfoLambdaUpdateWrapper.eq(SkuInfo::getId, skuId)
        //         .set(SkuInfo::getIsSale, 1);
        // skuInfoMapper.update(null, skuInfoLambdaUpdateWrapper);

        //添加布隆过滤
        RBloomFilter<Long> bloomFilter = redissonClient.getBloomFilter(RedisConst.SKU_BLOOM_FILTER);
        bloomFilter.add(skuId);

    }

    /**
     * SKU商品下架
     */
    @Override
    public void cancelSale(Long skuId) {
        LambdaUpdateWrapper<SkuInfo> skuInfoLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
        skuInfoLambdaUpdateWrapper.eq(SkuInfo::getId, skuId)
                .set(SkuInfo::getIsSale, 0);
        skuInfoMapper.update(null, skuInfoLambdaUpdateWrapper);
    }

    /**
     * 根据skuId获取商品详情页中SKU信息和图片信息
     */
    @Override
    public SkuInfoDTO getSkuInfo(Long skuId) {
        // 获取基本信息
        SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
        // 获取SKU商品的图片信息
        List<SkuImage> skuImages = skuImageMapper.getSkuImages(skuId);
        skuInfo.setSkuImageList(skuImages);
        return skuInfoConverter.skuInfoPO2DTO(skuInfo);
    }

    /**
     * 根据skuId获取商品详情页中SKU的价格
     */
    @Override
    public BigDecimal getSkuPrice(Long skuId) {
        SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
        return skuInfo.getPrice();
    }

    /**
     * 根据skuId和spuId获取商品详情页的商品销售属性列表
     */
    @Override
    public List<SpuSaleAttrInfoDTO> getSpuSaleAttrListCheckBySku(Long skuId, Long spuId) {
        List<SpuSaleAttrInfo> spuSaleAttrInfos = spuSaleAttrInfoMapper.selectSpuSaleAttrListCheckedBySku(skuId, spuId);
        return spuInfoConverter.spuSaleAttrInfoPOs2DTOs(spuSaleAttrInfos);
    }

    /**
     * 根据skuId获取商品详情页的平台属性列表 - 规格和包装信息
     */
    @Override
    public List<PlatformAttrInfoDTO> getPlatformAttrInfoBySku(Long skuId) {
        List<PlatformAttrInfo> platformAttrInfos = platformAttrInfoMapper.selectPlatformAttrInfoListBySkuId(skuId);
        return platformAttrConverter.platformAttrInfoPOs2DTOs(platformAttrInfos);
    }

    /**
     * 拼接属性值信息
     */
    @Override
    public Map<String, Long> getSkuValueIdsMap(Long spuId) {
        // todo 不懂
        HashMap<String, Long> skuValueIdsMap = new HashMap<>();
        List<SkuSaleAttrValuePermutation> skuValueIds = skuSaleAttrValueMapper.selectSaleAttrValuesBySpu(spuId);
        for (SkuSaleAttrValuePermutation skuValueId : skuValueIds) {
            skuValueIdsMap.put(skuValueId.getSkuSaleAttrValuePermutation(), skuValueId.getSkuId());
        }
        return skuValueIdsMap;
    }
}
